home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / KURZEL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-03  |  8.6 KB  |  442 lines
  1. #include "global.h"
  2. #include "edit.h"
  3. #include "file.h"
  4. #include "icon.h"
  5. #include "menu.h"
  6. #include "obj.h"
  7. #include "rsc.h"
  8. #include "scroll.h"
  9. #include "tasten.h"
  10. #include "text.h"
  11. #include "windows.h"
  12. #include "kurzel.h"
  13.  
  14. /*
  15.  * Exportierte Variablen
  16.  */
  17. BOOLEAN    krz_loaded;
  18.  
  19. /**************************************************************************/
  20.  
  21.  
  22. #define MNAME_LEN        15
  23. #define KRZ_MAX_LEN    8
  24.  
  25. typedef struct
  26. {
  27.     UBYTE    name[MNAME_LEN+1];
  28.     PATH    file;
  29.     LONG    y;
  30.     WORD    x;
  31. }MARKE, *MARKEP;
  32.  
  33. #define KRZ_LEN(col)    (TEXT(col)[0])
  34. #define KRZ_TXT(col)    (TEXT(col)+1)
  35. #define ERSATZ(col)    (TEXT(col)+1+KRZ_MAX_LEN+1)
  36.  
  37. LOCAL RING        kurz;
  38. /* Sortierte Zeilen                                                                 */
  39. /* Am Anfang in umgedrehter Reihenfolge die Zeichen                     */
  40. /* des Kürzel als Null-Terminierender String                                 */
  41. /* davor noch die länge des Kürzel (Pascalähnlich)                        */
  42. /* 0 Kürzellänge, 1-9 Kürzel, ab der 10 Position der Ersatzstring    */
  43. LOCAL RING    auto_kurz;
  44. LOCAL MARKE    Marken[5];
  45.  
  46. LOCAL PATH    krz_name;    /* Name der aktuellen Kürzeldatei, oder leer */
  47.  
  48. /***************************************************************************/
  49. LOCAL VOID    go_to_marke(WORD nr);
  50.  
  51. LOCAL WORD  load_kurzel    (VOID);
  52. LOCAL VOID     clr_kurzel    (VOID);
  53. LOCAL WORD  add_kurzel    (LINEP col);
  54.  
  55. /***************************************************************************/
  56.  
  57. BOOLEAN goto_line_dial (VOID)
  58. {
  59.     WORD    antw;
  60.     UBYTE    s[12];
  61.  
  62.     objc_setstring(pos, GZEILE, "");
  63.  
  64.     Arrow_mouse();
  65.     antw = HndlDial(pos, 0, FALSE, NULL, NULL);
  66.     Last_mouse();
  67.     objc_getstring(pos, GZEILE, s);
  68.     if (antw == GOK && *s)
  69.     {
  70.         desire_x = 0;
  71.         desire_y = atol(s)-1;
  72.         return TRUE;
  73.     }
  74.     return FALSE;
  75. } /* mgoto */
  76.  
  77. /***************************************************************************/
  78. /* Verwaltung der Marken                                                                    */
  79. /***************************************************************************/
  80.  
  81. VOID del_marke(WORD nr)
  82. {
  83.     MARKEP    m;
  84.     UBYTE        *str;
  85.     WORD        len;
  86.  
  87.     if (nr>=0 && nr<=4)
  88.     {
  89.         m = Marken + nr;
  90.         m->file[0] = EOS;
  91.         m->name[0] = EOS;
  92.         str = menu[MMARKE1+nr].ob_spec.free_string + 5;
  93.         len = MNAME_LEN;
  94.         while ((--len)>=0)
  95.             *str++ = ' ';
  96.     }
  97. }
  98.  
  99. VOID set_marke(WORD nr, CONST UBYTE *name, PATH file, LONG y, WORD x)
  100. {
  101.     MARKEP    m;
  102.     UBYTE        n[MNAME_LEN+1];
  103.  
  104.     if (nr>=0 && nr<=4)
  105.     {
  106.         m = Marken+nr;
  107.         m->x = x;
  108.         m->y = y;
  109.         *(UBYTE*)COPYB(n,name,MNAME_LEN) = EOS;
  110.         strcpy(m->name, n);
  111.         strcpy(m->file, file);
  112.         if (n[0]==EOS)
  113.             file_name(m->file, n, FALSE);
  114.         fillup_menu(MMARKE1 + nr, n, 5);
  115.     }
  116. }
  117.  
  118. VOID get_marke(WORD nr, UBYTE *name, PATH file, LONG *y, WORD *x)
  119. {
  120.     if (nr>=0 && nr<=4)
  121.     {
  122.         MARKEP    m;
  123.  
  124.         m = Marken+nr;
  125.         *x = m->x;
  126.         *y = m->y;
  127.         strcpy(name,m->name);
  128.         strcpy(file,m->file);
  129.     }
  130.     else
  131.     {
  132.         name[0] = EOS;
  133.         file[0] = EOS;
  134.     }
  135. }
  136.  
  137. VOID init_marken(VOID)
  138. {
  139.     WORD        i;
  140.     MARKEP    m;
  141.  
  142.     for (i=5,m=Marken; (--i)>=0; m++)
  143.     {
  144.         m->file[0] = EOS;
  145.         m->name[0] = EOS;
  146.     }
  147.     init_textring(&kurz);
  148.     init_textring(&auto_kurz);
  149. }
  150.  
  151. VOID goto_marke(WORD nr)
  152. {
  153.     PATH    file;
  154.     UBYTE    name[12];
  155.     LONG    y;
  156.     WORD    x, icon;
  157.  
  158.     if (global_shift)
  159.         del_marke(nr);
  160.     else
  161.     {
  162.         get_marke(nr,name,file,&y,&x);
  163.         if (file[0]!=EOS)
  164.         {
  165.             icon = still_loaded(file);
  166.             if (icon<0)
  167.                 icon = load_edit(file,FALSE,-1,-1,NULL);
  168.             if (icon>=0)
  169.             {
  170.                 if (do_icon(icon,DO_OPEN)<0)
  171.                     note(1, NOWINDOW);
  172.                 desire_y = y;
  173.                 desire_x = x;
  174.                 Icon_edit(icon,DO_GOTO);
  175.             }
  176.         }
  177.     }
  178. }
  179.  
  180. VOID config_marken(TEXTP t_ptr)
  181. {
  182.     WORD    antw;
  183.     PATH    file;
  184.     UBYTE    name[14];
  185.     LONG    y;
  186.     WORD    x, i;
  187.  
  188.     select_objc(marken, MRK1, TRUE);
  189.     for (i=1; i<5; i++)
  190.         select_objc(marken, MRK1+i, FALSE);
  191.     for (i=0; i<5; i++)
  192.     {
  193.         get_marke(i, name, file, &y, &x);
  194.         objc_setstring(marken, MRKTXT1+i, name);
  195.     }
  196.     Arrow_mouse();
  197.     antw = HndlDial(marken, 0, FALSE, NULL, NULL);
  198.     Last_mouse();
  199.     if (antw == MRKOK)
  200.     {
  201.         for (i=0; i<5; i++)
  202.             if (get_select(marken,MRK1+i))
  203.                 break;
  204.         objc_getstring(marken, MRKTXT1+i, name);
  205.         set_marke(i, name, t_ptr->filename, t_ptr->ypos, t_ptr->xpos);
  206.     }
  207. }
  208.  
  209. /***************************************************************************/
  210. /* Verwaltung der Kürzel                                                                    */
  211. /***************************************************************************/
  212.  
  213.  
  214. VOID clr_kurzel(VOID)
  215. {
  216.     free_textring(&kurz);
  217.     free_textring(&auto_kurz);
  218.     krz_loaded = FALSE;
  219. }
  220.  
  221. VOID do_kurzel(TEXTP t_ptr, BOOLEAN online)
  222. {
  223.     BOOLEAN    set_pos, save_insert;
  224.     WORD        xw, i, len;
  225.     UBYTE        *str, buffer[KRZ_MAX_LEN+1];
  226.     LINEP        col;
  227.     RINGP        k;
  228.  
  229.     if (online)
  230.         k = &auto_kurz;
  231.     else
  232.         k = &kurz;
  233.  
  234.     if (ist_leer(k))
  235.         return;
  236.  
  237.     xw = t_ptr->xpos;
  238.     if (xw == 0)
  239.         return;
  240.     str = TEXT(t_ptr->cursor_line)+xw;
  241.     i = 0;
  242.     len = min(xw,KRZ_MAX_LEN);
  243.     while (len>0)                                                        /* umdrehen */
  244.     {
  245.         buffer[i++] = *(--str);
  246.         len--;
  247.     }
  248.     buffer[i] = EOS;                                                    /* abschliessen */
  249.  
  250.     /* longest Match */
  251.     for (col=FIRST(k); TRUE; NEXT(col))
  252.     {
  253.         if (IS_TAIL(col))
  254.         {
  255.             if (!online)            /* wenn man Auto-Kürzel hat, pings sonst bei */
  256.                 mybeep();            /* jedem Zeichen, das kein Kürzel ist! */
  257.             return;
  258.         }
  259.         len = strncmp(buffer,KRZ_TXT(col),KRZ_LEN(col));
  260.         if (len == 0)
  261.             break;
  262.         if (len > 0)
  263.         {
  264.             if (!online)            /* dito. */
  265.                 mybeep();
  266.             return;
  267.         }
  268.     }
  269.  
  270.     /*
  271.      * Damit während der Kürzelexpandierung NICHT automatisch
  272.      * eingerückt wird, merken wir uns die Einstellung und schalten es ab!
  273.      * Kürzel, die mehrzeilig sind und mit Blanks/TABs beginnen, erscheinen
  274.      * sonst nicht korrekt.
  275.     */
  276.     save_insert = t_ptr->loc_opt->einruecken;
  277.     t_ptr->loc_opt->einruecken = FALSE;
  278.  
  279.     len = KRZ_LEN(col);
  280.     if (overwrite)
  281.         while ((--len)>=0) char_left(t_ptr);
  282.     else
  283.         while ((--len)>=0) char_bs(t_ptr);
  284.     str = ERSATZ(col);
  285.     set_pos = FALSE;
  286.     for (i=col->len-(KRZ_MAX_LEN+2); (--i)>=0; )
  287.     {
  288.         if (*str == '^' && i > 0 && str[1] == '^')
  289.         {
  290.             char_cr(t_ptr);
  291.             restore_edit();                        /* sonst entstehen komische Effekte */
  292.             xw++;
  293.             str++;
  294.             i--;
  295.         }
  296.         else if (*str!='~' || set_pos)        /* das erste '~'-Zeichen zählt */
  297.         {
  298.             char_insert(t_ptr, *str);
  299.             xw++;
  300.         }
  301.         else
  302.         {
  303.             set_pos = TRUE;
  304.             xw = 0;
  305.         }
  306.         str++;
  307.     }
  308.     if (set_pos)
  309.         while ((--xw)>=0) char_left(t_ptr);
  310.  
  311.     /*
  312.      * Und wieder herstellen
  313.     */
  314.     t_ptr->loc_opt->einruecken = save_insert;
  315. }
  316.  
  317. /* return 1 : kein Speicher mehr => abbruch */
  318. /*        0 : alles ok                      */
  319. WORD add_kurzel(LINEP col)
  320. {
  321.     WORD        len, i;
  322.     UBYTE        *str, buffer[260], *start;
  323.     LINEP        c;
  324.     BOOLEAN    online;
  325.  
  326.     krz_loaded = TRUE;
  327.     if (col->len<2)
  328.         return(0);
  329.     if (col->len>MAX_LINE_LEN-KRZ_MAX_LEN)
  330.         return(0);
  331.     if (!ist_mem_frei())
  332.         return (1);
  333.     start = strchr(TEXT(col),'=');                    /* start zeigt auf Ersatztext */
  334.     if (start==NULL)
  335.         return(0);
  336.     start++;
  337.     /* WS am Anfang überspringen */
  338.     for (str=TEXT(col); *str==' ' || *str=='\t'; str++) ;
  339.     if (str[0]=='#' || str[0]=='=' ||
  340.         (str[0]=='*' && str[1]=='='))
  341.         return(0);                                    /* Kommentarzeile oder kein Kurzel */
  342.     len = 0;
  343.     while (len<KRZ_MAX_LEN && *str!=' ' && *str!='\t' && *str!='=')    /* Ende suchen */
  344.     {
  345.         len++; str++;
  346.     }
  347.     if (start[-2]=='*')                                    /* auto. Kürzel */
  348.     {
  349.         online = TRUE;
  350.         if (*str=='=')
  351.         {
  352.             str--;
  353.             len--;
  354.         }
  355.     }
  356.     else
  357.         online = FALSE;
  358.     buffer[0] = len;                                        /* vorne Länge */
  359.     i = 1;
  360.     while (len>0)                                            /* umdrehen */
  361.     {
  362.         buffer[i++] = *(--str);
  363.         len--;
  364.     }
  365.     buffer[i] = EOS;                                        /* abschliessen */
  366.     len = (short) strlen(start);
  367.     COPYB(buffer+KRZ_MAX_LEN+2,start,len);
  368.     len += (KRZ_MAX_LEN+2);
  369.  
  370.     c = FIRST(&kurz);
  371.     if (ist_leer(&kurz))
  372.         INSERT(&c,0,len,buffer);
  373.     else
  374.     {
  375.         while (!IS_TAIL(c) && strcmp(KRZ_TXT(c),buffer+1)>0)
  376.             NEXT(c);
  377.         col_insert(c->vorg,new_col_w(buffer,len));
  378.         kurz.lines++;
  379.     }
  380.     if (online)
  381.     {
  382.         c = FIRST(&auto_kurz);
  383.         if (ist_leer(&auto_kurz))
  384.             INSERT(&c,0,len,buffer);
  385.         else
  386.         {
  387.             while (!IS_TAIL(c) && strcmp(KRZ_TXT(c),buffer+1)>0)
  388.                 NEXT(c);
  389.             col_insert(c->vorg,new_col_w(buffer,len));
  390.             auto_kurz.lines++;
  391.         }
  392.     }
  393.     return(0);
  394. }
  395.  
  396. WORD load_kurzel(VOID)
  397. {
  398.     LONG            anz;
  399.     RING            t;
  400.     LINEP            lauf;
  401.     WORD            erg;
  402.     LineEnding    dummy;
  403.  
  404.     if (krz_name[0] == EOS)
  405.         return 0;
  406.  
  407.     erg = 1;
  408.     init_textring(&t);
  409.     if (load_datei(krz_name, &t, FALSE, &dummy)==0)
  410.     {
  411.         anz = t.lines;
  412.         lauf = FIRST(&t);
  413.         if (anz)
  414.         {
  415.             clr_kurzel();                            /* alte Kürzel löschen */
  416.             while ((--anz)>=0)
  417.             {
  418.                 if (add_kurzel(lauf)) break;
  419.                 NEXT(lauf);
  420.             }
  421.         }
  422.         erg = 0;
  423.     }
  424.     kill_textring(&t);
  425.     return erg;
  426. }
  427.  
  428. VOID    ch_kurzel(CONST UBYTE *name, BOOLEAN force_load)
  429. {
  430.     if (name[0] == EOS)
  431.     {
  432.         clr_kurzel();
  433.         krz_name[0] = EOS;
  434.         return;
  435.     }
  436.     if ((strcmp(name, krz_name) != 0) || (force_load))
  437.     {
  438.         strcpy(krz_name, name);
  439.         load_kurzel();
  440.     }
  441. }
  442.